Schlick can't bea twosided fresnel, it only works for the front face

whats the difference between getOrientedEtaRcps and getRefractionOrientedEta ?

I see, one is the reciprocal, btw getRefractionOrientedEta must be a scalar type return cause its used for geometric refraction

shouldn't you take the float in the dummy_impl to be T::scalar_type or something from the NDF

I'm not sure why but I'm unable to do

template<typename T>
using sample_t = SLightSample<ray_dir_info::SBasic<T> >;

and pass in T::scalar_type without the concept not working

shouldn't you do typename T::scalar_type or something ?

it looks to me like every NDF needs to define:

this_t
scalar_type
vector2_type
vector3_type
IsAnisotropic
IsBSDF // this is badly named, should be SupportsTransmission or !ReflectanceOnly cause NDF is a concept apart and below a BSDF
NDFSurfaceType // should be renmaed to avoid the NDF::NDF tautology, maybe SupportedPaths
_Clamp
RequiredInteraction
RequiredMicrofacetCache

lets make it into a macro in ndf.hlsl

this method seems identical for Anisotropic and Isotropic bechmann, why specialize twice?

actually 3 or 4 methods (G2_over_G1, correlated, Lambda, DG1 Query overload) here seem identical with templated queries, its just the template constraint on the cache that changes, should be moved down into the most derived class

First, NBL_FUNC_REQUIRES is itself an enable_if, so I wouldn't write

template<class MicrofacetCache, typename C=bool_constant<!IsBSDF> NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache>)
enable_if_t<C::value && !IsBSDF, quant_query_type> createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)

but simply

template<class MicrofacetCache, typename C=bool_constant<!IsBSDF> NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache> && C::value && !IsBSDF)
quant_query_type createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)

Also in cases where the if-else branch wont generate invalid code, you can use NBL_IF_CONSTEXPR without worry

template<class MicrofacetCache> NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache>)
quant_query_type createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)
{
   quant_query_type retval; // only has members for refraction
   NBL_IF_CONSTEXPR(SupportsTransmission)
   {
        retval.VdotHLdotH = cache.getVdotHLdotH();
        retval.VdotH_etaLdotH = cache.getVdotH() + orientedEta * cache.getLdotH();
   }
   return retval;
}

Finally, don't the getVdotH and getLdotH need ABS clamping or something?
If no, explain why in the comments

why is the NDFQuantQuery which seems only useful for ndf/microfacet_to_light_transform.hlsl not defined there? and outside of impl with a better name?

btw you could have a createDualMeasureQuantity that takes the Quant Query instead of individual VdotHLdotH and VdotH_etaLDotH arguments, then you wouldn't need two copies each of D and DG1

this is identical for isotropic and anisotropic, and so are the query taking methods: G1_wo_numerator_devsh_part, correlated_wo_numerator, correlated, G2_over_G1 as long as your requires clauses use RequiredInteraction and RequiredMicrofacetCache

I think its possible to move these into NBL_IUF_CONSTEXPR if you just made a struct which just concerns itself with

scalar_type orientedEta = impl::get_orientedEta_helper(fresnel); // return `fresnel.getRefractionOrientedEta()` if `SupportsTransmission` requiring a twosided fresnel, otherwise return uninitialized var

well your getOrientedFrensel already does what my suggested getOrientedEta_helper should do, (minus a call to getRefractionOrientedEta()

you don't need check_TIR_helper, just call the cache.isValid() directly

whats the dummy in place of?

there's probably a faster way to make an invalid sample, require a createInvalid factory

either rewrite the if so its > and put the valid case code inside, or assert that getNdotV is not NaN, as it stands a NaN will proceed

there should really be just a sample_type::createInvalid and this vode with TBN should go into the valid if-case

Also the NdotL computation should be overwritten by 2.f*cache.getVdotH()*localH.z - localV.z which you compute for the if-statement (the quantitiy you check to see if the sample has invalid path).

you can asset this as soon as VdotH is known with a comment about VNDF sampling

hoist this check all the way to when VdotH and transmitted is first calculated

would be good to record all this in a comment #930 (comment)

push calculation till last moment

this is not a valid computation of NdotL for the BSDF, this is the reflection equation

if you follow

then using the NdotH==localH.z, NdotV and the LdotH you already compute for cache.isValid() you can compute NdotL as:

const float viewShortenFactor = hlsl::mix<scalar_type>(1.0f, rcpOrientedEta, transmitted);
const float NdotL = localH.z * (VdotH*viewShortenFactor + LdotH) - NdotV * viewShortenFactor;

you don't need to compute dot(_N,H) its literally localH.z

also assert that the cache.isValid() right away after this (it should be, by construction)

leave a comment that the call rr makes to getNdotTorR and mix as well as a good part of the comuptations should CSE with our computation of NdotL (which should be hoisted above the reflect/refract code)

I think you can collapse the two methods if you use a REQUIRES(RequiredInteraction<Interaction> && RequiredCache<Cache>) similarly for other methods

you could get rid of simple passthrough if you put a REQUIRES on the __quotient_and_pdf and removed the __

hmm actually since Eval is not Quotient, it should return 0 whenever PDF would have been INF, and therefore whenever Eval is inf, you can just return 0

you could even add an NBL_REF_ARG(bool) to the D signature for a boolean side-channel of isInf because it pays for the NDF to set that boolean as soon as possible (before a chain or multiplies and divides, compiler won't hoiust your INF checks before divisions by measure factors, etc.)

we must let NDF provide a Dcorrelated method, and if detected, use that instead of this, because we miss an optimization opportunity with GGX

We could actually do this in the following way

        using quant_query_type = typename ndf_type::quant_query_type;
        scalar_type dummy;
        quant_query_type qq = ndf.template createQuantQuery<MicrofacetCache>(cache, dummy);

        quant_type D = ndf.template D<sample_type, Interaction, MicrofacetCache>(qq, _sample, interaction, cache);
        scalar_type DG = D.projectedLightMeasure;
        if (D.microfacetMeasure < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
        {
            using g2g1_query_type = typename ndf_type::g2g1_query_type;
            g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction);
            DG *= ndf.template correlated<sample_type, Interaction>(gq, _sample, interaction);
        }
        
        // overwrites DG with NDF's `Dcorrelated` method, also `asserts` that the optimal method returns similar to above
        impl::overwrite_DG<ndf_type,sample_type,Interaction,Cache>(/*NBL_REF_ARG*/DG,ndf,...);

continues #930 (comment)

want to either comment or stick it in the name or the Query concept comment that its the wo_numerator

Query is not G1, this kinda seems to not make sense to me as a thing to return from DG1, I'm expecting NDF measure times the real G1 from a function called DG1

A rename might be in order, into DG1over4NdotV?